package com.infoland.afanmall.base.activity;

import android.app.Application;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.os.Build;
import android.os.Handler;
import android.util.Log;

import com.blankj.utilcode.util.Utils;
import com.infoland.afanmall.base.util.CONST;
import com.infoland.afanmall.base.util.CacheKit;
import com.infoland.afanmall.base.util.LogKit;
import com.infoland.afanmall.wxapi.WXEntryActivity;
import com.lzy.okgo.OkGo;
import com.squareup.leakcanary.LeakCanary;
import com.tencent.mm.opensdk.openapi.WXAPIFactory;
import com.vondear.rxtools.RxNetTool;
import com.vondear.rxtools.RxTool;

import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import okhttp3.OkHttpClient;

public class MyApplication extends Application {
    private static long time = 20 * 1000;
    private ConnectivityManager connectivityManager;
    public static ArrayList<String> arrayList;

    @Override
    public void onCreate() {
        super.onCreate();
//        arrayList = new ArrayList<>();
//        String aa1 = "10";
//        ArrayList<String> objects = new ArrayList<>();
//        objects.add(aa1);
//        arrayList.add(objects.get(0));
//        objects.set(0, "11111");
//        LogKit.E("ttttttttttttttttt ---->   ", "  " + arrayList.get(0));
//        LogKit.E("ttttttttttttttttt ---->   ", "  " + objects.get(0));
        if (LeakCanary.isInAnalyzerProcess(this)) {
            //此过程专用于LeakCanary进行堆分析。
            // 您不应该在此过程中初始化您的应用。
            return;
        }
        LeakCanary.install(this);
        //普通应用初始化代码......
        CacheKit.APP_CONTEXT = getApplicationContext();
        registToWX();//注册微信
        Utils.init(this);//注册工具类
        RxTool.init(getApplicationContext());//注册工具类
        initOkHttp();//注册Http
        setInternetLinster();//注册网络监听
//        String sha1String = ToolsKit.getSHA1String("123456");
//        LogKit.E("  密码 sha1加密 ", "  " + sha1String.toLowerCase());
    }

    //注册微信
    private void registToWX() {
        //AppConst.WEIXIN.APP_ID是指你应用在微信开放平台上的AppID，记得替换。
        WXEntryActivity.wxapi = WXAPIFactory.createWXAPI(this, CONST.WEIXIN_APP_ID, true);
        // 将该app注册到微信
        WXEntryActivity.wxapi.registerApp(CONST.WEIXIN_APP_ID);
    }

    //注册 OkHttp
    private void initOkHttp() {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.readTimeout(time, TimeUnit.MILLISECONDS);        //全局的读取超时时间
        builder.writeTimeout(time, TimeUnit.MILLISECONDS);        //全局的写入超时时间
        builder.connectTimeout(time, TimeUnit.MILLISECONDS);        //全局的连接超时时间
        OkGo.getInstance().init(this)                       //必须调用初始化
                .setOkHttpClient(builder.build())               //建议设置OkHttpClient，不设置将使用默认的
//                .setCacheMode(CacheMode.NO_CACHE)               //全局统一缓存模式，默认不使用缓存，可以不传
//                .setCacheTime(CacheEntity.CACHE_NEVER_EXPIRE)   //全局统一缓存时间，默认永不过期，可以不传
                .setRetryCount(3)                          //全局统一超时重连次数，默认为三次，那么最差的情况会请求4次(一次原始请求，三次重连请求)，不需要可以设置为0
//                .addCommonHeaders(headers)                      //全局公共头
//                .addCommonParams(params);                       //全局公共参数
        ;
    }

    //注册网络监听
    public void setInternetLinster() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
            // 请注意这里会有一个版本适配bug，所以请在这里添加非空判断
            if (connectivityManager != null) {
                NetworkRequest build = new NetworkRequest.Builder().build();
                connectivityManager.requestNetwork(build, new ConnectivityManager.NetworkCallback() {
                    /**
                     * 网络可用的回调
                     * */
                    @Override
                    public void onAvailable(Network network) {
                        super.onAvailable(network);
                        updateInternet();
                        Log.e("lzp", "onAvailable 网络可用");
                    }

                    /**
                     * 网络丢失的回调
                     * */
                    @Override
                    public void onLost(Network network) {
                        super.onLost(network);
                        new Handler().postDelayed(() -> updateInternet(), 4000);
                        Log.e("lzp", "onLost 网络断开");
                    }


                    /**
                     *  按照官方的字面意思是，当我们的网络的某个能力发生了变化回调，那么也就是说可能会回调多次
                     *
                     *  之后在仔细的研究
                     * */
                    @Override
                    public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
                        super.onCapabilitiesChanged(network, networkCapabilities);
                        updateInternet();
                        Log.e("lzp", "onCapabilitiesChanged  网络类型变更");
                    }

                    /**
                     * 在网络失去连接的时候回调，但是如果是一个生硬的断开，他可能不回调
                     * */
                    @Override
                    public void onLosing(Network network, int maxMsToLive) {
                        super.onLosing(network, maxMsToLive);
                        Log.e("lzp", "onLosing");
                    }

                    /**
                     * 按照官方注释的解释，是指如果在超时时间内都没有找到可用的网络时进行回调
                     * */
                    @Override
                    public void onUnavailable() {
                        super.onUnavailable();
                        Log.e("lzp", "onUnavailable");
                    }

                    /**
                     * 当建立网络连接时，回调连接的属性
                     * */
                    @Override
                    public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
                        super.onLinkPropertiesChanged(network, linkProperties);
                        Log.e("lzp", "onLinkPropertiesChanged");
                    }

                });
            }
        }
    }

    //更新网络状态
    private synchronized void updateInternet() {
        if (RxNetTool.isAvailable(CacheKit.APP_CONTEXT)) {
            LogKit.E("updateInternet ---->   ", " 网络可用 ");
            if (RxNetTool.isWifi(CacheKit.APP_CONTEXT)) {
                LogKit.E("updateInternet ---->   ", " 现在是WIFI ");
            } else {
                if (RxNetTool.is4G(CacheKit.APP_CONTEXT)) {
                    LogKit.E("updateInternet ---->   ", " 现在是 4G移动网络 ");
                } else if (RxNetTool.is3rd(CacheKit.APP_CONTEXT)) {
                    LogKit.E("updateInternet ---->   ", " 现在是 3G移动网络 ");
                } else {
                    LogKit.E("updateInternet ---->   ", " 现在是 2G移动网络 ");
                }
            }
        } else {
            LogKit.E("updateInternet ---->   ", "  网络不可用");
            OkGo.getInstance().cancelAll();
        }
    }
}
